
//返回结果
// 定义响应状态码和消息  
const SUCCESS_CODE = '0';
const FAILURE_CODE = '1';
const SUCCESS_MESSAGE = 'true';
const FAILURE_MESSAGE = 'false';

const jsonWrite = (res, result, err, totalPages = 0) => {
  const response = {
    code: err ? FAILURE_CODE : SUCCESS_CODE,
    success: err ? FAILURE_MESSAGE : SUCCESS_MESSAGE,
    message: err || '',
    data: err ? null : result,
    totalPages: totalPages
  };

  return res.json(response);
};

//获取客户端ip
const getJsonData = (result) => {
  let map = {}; // 使用对象来映射labelName到其数据数组  
  let dest = []; // 存储最终结果的数组  

  for (let i = 0; i < result.length; i++) {
    const ai = result[i];
    const labelName = ai.labelName;

    if (!map[labelName]) {
      // 如果labelName不存在于map中，则创建一个新的对象，并初始化data数组  
      map[labelName] = { labelName, data: [ai] };
      dest.push(map[labelName]); // 添加到最终结果数组中  
    } else {
      // 如果labelName已存在于map中，则直接向其data数组添加新数据  
      map[labelName].data.push(ai);
    }
  }

  return dest;
};

/*
使用 Math.min 来直接获取两个数组长度中的较小值，而不是使用条件语句。

将 arguments 替换为明确的参数名 ary1 和 ary2，使代码更易于阅读和维护。

使用 map 方法替代 for 循环来遍历较短的数组，并且只在 slice 后的数组上操作，这可以避免不必要的边界检查。
*/

const aryJoinAry = (ary1, ary2) => {
  const minLength = Math.min(ary1.length, ary2.length);
  const longAry = ary1.length > ary2.length ? ary1 : ary2;
  let itemAry = [];

  // 使用数组方法 map 来简化循环逻辑  
  ary1.slice(0, minLength).map((item, index) => {
    itemAry.push(item + "-" + ary2[index]);
  });

  // 使用剩余元素扩展 itemAry  
  return itemAry.concat(longAry.slice(minLength));
};

const nowInDateBetween = (d1, d2) => {
  const dateNow = new Date(); // 获取当前时间，只计算一次  

  try {
    const dateBegin = new Date(d1); // 尝试解析开始日期  
    const dateEnd = new Date(d2); // 尝试解析结束日期  

    // 验证日期是否有效  
    if (isNaN(dateBegin.getTime()) || isNaN(dateEnd.getTime())) {
      throw new Error('Invalid date format');
    }

    // 计算时间差的天数  
    const beginDiff = (dateNow - dateBegin) / (24 * 3600 * 1000);
    const endDiff = (dateEnd - dateNow) / (24 * 3600 * 1000);

    // 检查当前日期是否在开始和结束日期之间  
    if (endDiff < 0) { // 已过期  
      return false;
    }
    if (beginDiff < 0) { // 没到开始时间  
      return false;
    }

    return true; // 在时间范围内  
  } catch (error) {
    // 抛出错误或进行其他错误处理  
    console.error('Error in nowInDateBetween:', error);
    return false; // 或根据需要返回其他值  
  }
};

// 封装一个函数来处理参数中的优先级逻辑  
const handlePriority = (params) => {
  let isPriority = 0;
  if (params.priority === "") {
    params.priority = null;
  } else if (params.priority > 0) {
    isPriority = 1;
  }
  return { isPriority, priority: params.priority };
}

// 封装一个函数来处理数据库查询的响应  
const handleDatabaseResponse = (res, result, err) => {
  if (err) {
    // 如果有错误，返回错误响应  
    jsonWrite(res, null, err);
  } else {
    // 如果没有错误，返回成功响应  
    jsonWrite(res, result, null);
  }
}

// 辅助函数，用于处理查询结果和响应  
const handleQuery = async (req, res, sql, params = []) => {
  try {
    const result = await pool.query(sql, params);
    jsonWrite(res, result, null);
  } catch (err) {
    jsonWrite(res, null, err);
  }
}

module.exports = {
  jsonWrite,
  getJsonData,
  aryJoinAry,
  nowInDateBetween,
  handlePriority,
  handleDatabaseResponse,
  handleQuery
}